Object migration in non-monolithic distributed applications

Object migration is usually applied to optimize distributed monolithic systems. In this paper, the authors investigate whether object migration can also be utilized in cooperative systems which consist of autonomous components. We show that object migration policies will not always optimize system performance. Rather they can reduce it drastically if different components apply these policies concurrently. Conventional run-time support for linguistic primitives which are usually used to express migration policies is adapted to cooperative systems. We show that two novel approaches, place-policy and reduction of attachment-transitiveness, can counter the degradation caused by conflicting policies. In order to restrict attachment-transitiveness we introduce dynamic relationships called \emph{alliances} between objects which explicitly define cooperation contexts. The effects of these modifications are evaluated by simulation

Assessing architectural evolution: A case study

This is the post-print version of the Article. The official published can be accessed from the link below - Copyright @ 2011 SpringerThis paper proposes to use a historical perspective on generic laws, principles, and guidelines, like Lehman’s software evolution laws and Martin’s design principles, in order to achieve a multi-faceted process and structural assessment of a system’s architectural evolution. We present a simple structural model with associated historical metrics and visualizations that could form part of an architect’s dashboard. We perform such an assessment for the Eclipse SDK, as a case study of a large, complex, and long-lived system for which sustained effective architectural evolution is paramount. The twofold aim of checking generic principles on a well-know system is, on the one hand, to see whether there are certain lessons that could be learned for best practice of architectural evolution, and on the other hand to get more insights about the applicability of such principles. We find that while the Eclipse SDK does follow several of the laws and principles, there are some deviations, and we discuss areas of architectural improvement and limitations of the assessment approach

Towards Transitory Encapsulation

Encapsulation and information hiding are essential and fundamental to object-oriented and aspect-oriented programming languages. These principles ensure that one part of a program does not depend on assumptions on the internal structure and logic of other parts of the program. While this assumption allows for clearly defined modules, interfaces and interaction protocols when software is initially developed, it is possible that rigid encapsulation causes problems, such as brittleness, as software changes and evolves over time. We suggest that, just as the strength of type systems have relaxed over time, perhaps structural boundaries could, too be relaxed. Perhaps there could be a new kind of flexible encapsulation: one that allows non-permanent and flexible boundaries between program part